home *** CD-ROM | disk | FTP | other *** search
/ The World of Computer Software / The World of Computer Software.iso / srcuc.zip / DOSKBD.C < prev    next >
C/C++ Source or Header  |  1992-06-04  |  34KB  |  1,374 lines
  1. /* -*-C-*-
  2.  
  3. $Header: /scheme/src/microcode/RCS/doskbd.c,v 1.7 1992/06/04 12:40:40 jinx Exp $
  4.  
  5. Copyright (c) 1992 Massachusetts Institute of Technology
  6.  
  7. This material was developed by the Scheme project at the Massachusetts
  8. Institute of Technology, Department of Electrical Engineering and
  9. Computer Science.  Permission to copy this software, to redistribute
  10. it, and to use it for any purpose is granted, subject to the following
  11. restrictions and understandings.
  12.  
  13. 1. Any copy made of this software must include this copyright notice
  14. in full.
  15.  
  16. 2. Users of this software agree to make their best efforts (a) to
  17. return to the MIT Scheme project any improvements or extensions that
  18. they make, so that these may be included in future releases; and (b)
  19. to inform MIT of noteworthy uses of this software.
  20.  
  21. 3. All materials developed as a consequence of the use of this
  22. software shall duly acknowledge such use, in accordance with the usual
  23. standards of acknowledging credit in academic research.
  24.  
  25. 4. MIT has made no warrantee or representation that the operation of
  26. this software will be error-free, and MIT is under no obligation to
  27. provide any services, by way of maintenance, update, or otherwise.
  28.  
  29. 5. In conjunction with products arising from the use of this material,
  30. there shall be no use of the name of the Massachusetts Institute of
  31. Technology nor of any adaptation thereof in any advertising,
  32. promotional, or sales literature without prior written consent from
  33. MIT in each case. */
  34.  
  35. /* These flags determine how the code will behave. */
  36.  
  37. #define DOSX_USE_INT_INTERCEPT
  38. #define DOSX_RM_HANDLER_UNTOUCHED
  39. #define DOSX_PM_HANDLER_UNTOUCHED
  40. /* #define DOSX_RM_HANDLER_REAL */
  41. #define DPMI_RM_HANDLER_REAL
  42. #define DPMI_PM_HANDLER_UNTOUCHED
  43.  
  44. #include <stdlib.h>
  45. #include <stdio.h>
  46. #include <errno.h>
  47. #include <bios.h>
  48. #include <dos.h>
  49. #include <int.h>
  50. #include "msdos.h"
  51.  
  52. #ifdef getDS
  53. #undef getDS
  54. #endif
  55.  
  56. #include "dossys.h"
  57. #include "dosinsn.h"
  58. #include "doskbd.h"
  59.  
  60. #ifndef ELOOP
  61. #  define ELOOP 2000
  62. #endif
  63.  
  64. #ifndef EFAULT
  65. #  define EFAULT 2001
  66. #endif
  67.  
  68. /* Tables mapping scan codes to ASCII characters.
  69.    Entries with NULL (\0) should not be mapped by the
  70.    Scheme keyboard ISR.  Let the default handler map them.
  71.  */
  72.  
  73. static unsigned char
  74. shifted_scan_code_to_ascii[] =
  75. { 
  76.     '\0',        /* 0 */
  77.     '\033',        /* 1 */
  78.     '!',        /* 2 */
  79.     '@',        /* 3 */
  80.     '#',        /* 4 */
  81.     '$',        /* 5 */
  82.     '%',        /* 6 */
  83.     '^',        /* 7 */
  84.     '&',        /* 8 */
  85.     '*',        /* 9 */
  86.     '(',        /* 10 */
  87.     ')',        /* 11 */
  88.     '_',        /* 12 */
  89.     '+',        /* 13 */
  90.     '\177',        /* 14 */
  91.     '\t',        /* 15 */
  92.     'Q',        /* 16 */
  93.     'W',        /* 17 */
  94.     'E',        /* 18 */
  95.     'R',        /* 19 */
  96.     'T',        /* 20 */
  97.     'Y',        /* 21 */
  98.     'U',        /* 22 */
  99.     'I',        /* 23 */
  100.     'O',        /* 24 */
  101.     'P',        /* 25 */
  102.     '{',        /* 26 */
  103.     '}',        /* 27 */
  104.     '\r',        /* 28 */
  105.     '\0',        /* 29 */
  106.     'A',        /* 30 */
  107.     'S',        /* 31 */
  108.     'D',        /* 32 */
  109.     'F',        /* 33 */
  110.     'G',        /* 34 */
  111.     'H',        /* 35 */
  112.     'J',        /* 36 */
  113.     'K',        /* 37 */
  114.     'L',        /* 38 */
  115.     ':',        /* 39 */
  116.     '\"',        /* 40 */
  117.     '~',        /* 41 */
  118.     '\0',        /* 42 */
  119.     '|',        /* 43 */
  120.     'Z',        /* 44 */
  121.     'X',        /* 45 */
  122.     'C',        /* 46 */
  123.     'V',        /* 47 */
  124.     'B',        /* 48 */
  125.     'N',        /* 49 */
  126.     'M',        /* 50 */
  127.     '<',        /* 51 */
  128.     '>',        /* 52 */
  129.     '?',        /* 53 */
  130.     '\0',        /* 54 */
  131.     '\0',        /* 55 */
  132.     '\0',        /* 56 */
  133.     ' '        /* 57 */
  134.   };
  135.     
  136. static unsigned char
  137. unshifted_scan_code_to_ascii[] =
  138. {
  139.     '\0',        /* 0 */
  140.     '\033',        /* 1 */
  141.     '1',        /* 2 */
  142.     '2',        /* 3 */
  143.     '3',        /* 4 */
  144.     '4',        /* 5 */
  145.     '5',        /* 6 */
  146.     '6',        /* 7 */
  147.     '7',        /* 8 */
  148.     '8',        /* 9 */
  149.     '9',        /* 10 */
  150.     '0',        /* 11 */
  151.     '-',        /* 12 */
  152.     '=',        /* 13 */
  153.     '\177',        /* 14 */
  154.     '\t',        /* 15 */
  155.     'q',        /* 16 */
  156.     'w',        /* 17 */
  157.     'e',        /* 18 */
  158.     'r',        /* 19 */
  159.     't',        /* 20 */
  160.     'y',        /* 21 */
  161.     'u',        /* 22 */
  162.     'i',        /* 23 */
  163.     'o',        /* 24 */
  164.     'p',        /* 25 */
  165.     '[',        /* 26 */
  166.     ']',        /* 27 */
  167.     '\r',        /* 28 */
  168.     '\0',        /* 29 */
  169.     'a',        /* 30 */
  170.     's',        /* 31 */
  171.     'd',        /* 32 */
  172.     'f',        /* 33 */
  173.     'g',        /* 34 */
  174.     'h',        /* 35 */
  175.     'j',        /* 36 */
  176.     'k',        /* 37 */
  177.     'l',        /* 38 */
  178.     ';',        /* 39 */
  179.     '\'',        /* 40 */
  180.     '`',        /* 41 */
  181.     '\0',        /* 42 */
  182.     '\\',        /* 43 */
  183.     'z',        /* 44 */
  184.     'x',        /* 45 */
  185.     'c',        /* 46 */
  186.     'v',        /* 47 */
  187.     'b',        /* 48 */
  188.     'n',        /* 49 */
  189.     'm',        /* 50 */
  190.     ',',        /* 51 */
  191.     '.',        /* 52 */
  192.     '/',        /* 53 */
  193.     '\0',        /* 54 */
  194.     '\0',        /* 55 */
  195.     '\0',        /* 56 */
  196.     ' '        /* 57 */
  197.   };
  198.  
  199. static unsigned char modifier_mask = 0x4f;
  200.  
  201. union RM_address
  202. {
  203.   unsigned fp;
  204.   struct
  205.     {
  206.       unsigned short off;
  207.       unsigned short seg;
  208.     } x;
  209. };
  210.  
  211. dos_boolean
  212. under_QEMM_386_p (void)
  213. {
  214.   unsigned int i;
  215.   union REGS iregs, oregs;
  216.  
  217.   iregs.h.al = 0x01;
  218.   iregs.x.bx = 0x5145;
  219.   iregs.x.cx = 0x4d4d;
  220.   iregs.x.dx = 0x3432;
  221.  
  222.   for (i = 0xc0; i <= 0xff; i++)
  223.   {
  224.     iregs.h.ah = i;
  225.     int86 (0x2f, &iregs, &oregs);
  226.     if (oregs.x.bx == 0x4f4b)
  227.       return (dos_true);
  228.   }
  229.   return (dos_false);
  230. }
  231.  
  232. dos_boolean
  233. under_DPMI_p (void)
  234. {
  235.   union REGS regs;
  236.   
  237.   regs.e.eax = 0x1686;
  238.   int86 (0x2f, ®s, ®s);
  239.   return (regs.x.ax == 0);
  240. }
  241.  
  242. static void
  243. normalize_RM_address (union RM_address * addr)
  244. {
  245.   if (addr->x.off > 0xf)
  246.   {
  247.     addr->x.seg += (addr->x.off >> 4);
  248.     addr->x.off = (addr->x.off & 0xf);
  249.   }
  250.   return;
  251. }
  252.  
  253. static dos_boolean
  254. install_kbd_hook_p (char * var_name)
  255. {
  256.   extern int strcmp_ci (char *, char *);
  257.   char * envvar = (DOS_getenv (var_name));
  258.  
  259.   if ((envvar != NULL) && ((strcmp_ci (envvar, "true")) == 0))
  260.     return (dos_true);
  261.   else
  262.     return (dos_false);
  263. }
  264.  
  265. /*
  266.    We would like to use Zortech's int_intercept with the following
  267.    routine under DOSX (or Phar Lap).
  268.  
  269.    Unfortunately, it does not work under QEMM386 or under MS Windows 3.1.
  270.    The real-mode call-back routine is apparently just plain broken.
  271.  
  272.    In addition, bypassing DOSX under DPMI 0.9 and using DPMI's
  273.    real-mode call backs does not work consistently, and the keyboard
  274.    interrupt happens only in real mode since we are capturing the
  275.    interrupt DOS uses to tell the BIOS that a scan code has arrived
  276.    after doing the handshake with the keyboard device itself.
  277.  
  278.    Thus, under DPMI, we install our own hard-coded real-mode keyboard
  279.    driver and don't bother with a protected mode handler.  All the
  280.    code is here in case it can be turned on in the future, perhaps for
  281.    a different DOS Extender or a new version of DPMI.
  282.  
  283.    Apparently telling DOSX to install a protected mode handler and
  284.    making it reflect real mode interrupts to protected mode does not
  285.    work consistently under QEMM386 either, thus we are now installing
  286.    a real-mode handler no matter what, although using different
  287.    mechanisms under DPMI and not DPMI.
  288.  */
  289.  
  290. #ifdef DOSX_USE_INT_INTERCEPT
  291.  
  292. #define PC_KBD_ALT_MASK            0x8
  293. #define PC_KBD_CTRL_MASK        0x4
  294. #define PC_KBD_SHIFT_MASK        0x3
  295. #define PC_KBD_CAPSL_MASK        0x40
  296.  
  297. #define DOS_HOOK_TRANSLATE_KEYSTROKE    0x4f
  298. #define DOS_KBD_FUNC_RECORD_KEYSTROKE    0x5
  299.  
  300. int
  301. bios_keyboard_handler(struct INT_DATA *pd)
  302. {
  303.   unsigned char scan_code, chord, ascii;
  304.   union REGS regs;
  305.  
  306.   if (pd->regs.h.ah != DOS_HOOK_TRANSLATE_KEYSTROKE)
  307.     return (INTERRUPT_CHAIN_NEXT);
  308.  
  309.   scan_code = (pd->regs.h.al);
  310.   if (scan_code >= (sizeof (shifted_scan_code_to_ascii)))
  311.     return (INTERRUPT_CHAIN_NEXT);
  312.  
  313.   chord = ((bioskey (_KEYBRD_SHIFTSTATUS)) & modifier_mask);
  314.  
  315.   if ((chord == 0) || (chord == PC_KBD_ALT_MASK))
  316.     ascii = ((int) unshifted_scan_code_to_ascii[scan_code]);
  317.   else
  318.     ascii = ((int) shifted_scan_code_to_ascii[scan_code]);
  319.  
  320.   if (ascii == 0)
  321.     return (INTERRUPT_CHAIN_NEXT);
  322.   if ((chord & PC_KBD_CTRL_MASK) != 0)
  323.     ascii &= ~0x60;            /* Controlify */
  324.   if (chord & PC_KBD_ALT_MASK)
  325.     ascii |= 0x80;            /* Metafy */
  326.   if (ascii == 0360)
  327.     return (INTERRUPT_CHAIN_NEXT);    /* Problems with M-p */
  328.   if ((ascii == 0200) || (ascii == 0))
  329.     scan_code = 3;            /* Problems with C-Space */
  330.  
  331.   /* Insert metafied char in bios buffer. */
  332.   regs.h.ah = DOS_KBD_FUNC_RECORD_KEYSTROKE;
  333.   regs.h.ch = scan_code;
  334.   regs.h.cl = ascii;
  335.   int86 (DOS_INTVECT_KEYBOARD_REQUEST, ®s, ®s);
  336.  
  337.   pd->regs.e.flags &= ~1;        /* clear CF, scan code ignored! */
  338.   return (INTERRUPT_RETURN);
  339. }
  340. #endif /* DOSX_USE_INT_INTERCEPT */
  341.  
  342. static void
  343. DPMI_PM_getvector (unsigned vecnum, unsigned * eip, unsigned * cs)
  344. {
  345.   union REGS regs;
  346.   
  347.   regs.x.ax = 0x204;
  348.   regs.h.bl = (vecnum & 0xff);
  349.   int86 (0x31, ®s, ®s);
  350.   * eip = regs.e.edx;
  351.   * cs = ((unsigned) regs.x.cx);
  352.   return;
  353. }
  354.  
  355. static int
  356. DPMI_PM_setvector (unsigned vecnum, unsigned eip, unsigned cs)
  357. {
  358.   union REGS regs;
  359.   
  360.   regs.x.ax = 0x205;
  361.   regs.h.bl = (vecnum & 0xff);
  362.   regs.e.edx = eip;
  363.   regs.x.cx = ((unsigned short) cs);
  364.   int86 (0x31, ®s, ®s);
  365.   return (((regs.e.flags & 1) == 0) ? DOS_SUCCESS : DOS_FAILURE);
  366. }
  367.  
  368. static void
  369. DPMI_RM_getvector (unsigned vecnum, unsigned short * ip, unsigned short * cs)
  370. {
  371.   union REGS regs;
  372.   
  373.   regs.x.ax = 0x200;
  374.   regs.h.bl = (vecnum & 0xff);
  375.   int86 (0x31, ®s, ®s);
  376.   * ip = regs.x.dx;
  377.   * cs = regs.x.cx;
  378.   return;
  379. }
  380.  
  381. static int
  382. DPMI_RM_setvector (unsigned vecnum, unsigned short ip, unsigned short cs)
  383. {
  384.   union REGS regs;
  385.   
  386.   regs.x.ax = 0x201;
  387.   regs.h.bl = (vecnum & 0xff);
  388.   regs.x.cx = cs;
  389.   regs.x.dx = ip;
  390.   int86 (0x31, ®s, ®s);
  391.   return (((regs.e.flags & 1) == 0) ? DOS_SUCCESS : DOS_FAILURE);
  392. }
  393.  
  394. #ifdef DPMI_RM_HANDLER_PROTECTED
  395.  
  396. struct DPMI_RM_REGS
  397. {
  398.   unsigned long edi;        /* 0 */
  399.   unsigned long esi;        /* 4 */
  400.   unsigned long ebp;        /* 8 */
  401.   unsigned long esp;        /* 12 */
  402.   unsigned long ebx;        /* 16 */
  403.   unsigned long edx;        /* 20 */
  404.   unsigned long ecx;        /* 24 */
  405.   unsigned long eax;        /* 28 */
  406.   unsigned short flags;        /* 30 */
  407.   unsigned short es;        /* 32 */
  408.   unsigned short ds;        /* 34 */
  409.   unsigned short fs;        /* 36 */
  410.   unsigned short gs;        /* 38 */
  411.   unsigned short ip;        /* 40 */
  412.   unsigned short cs;        /* 42 */
  413.   unsigned short sp;        /* 44 */
  414.   unsigned short ss;        /* 48 */
  415.   unsigned short pad;        /* 50 */
  416.   unsigned long old_vector_ip;    /* 52 */
  417.   unsigned long old_vector_cs;    /* 56 */
  418. };
  419.  
  420. static int
  421. DPMI_allocate_RM_call_back (unsigned short * cb_ip,
  422.                 unsigned short * cb_cs,
  423.                 unsigned eip, unsigned cs,
  424.                 unsigned RM_regs, unsigned ds)
  425. {
  426.   union REGS regs;
  427.   struct SREGS sregs;
  428.   
  429.   segread (& sregs);
  430.   regs.x.ax = 0x303;
  431.   regs.e.esi = eip;
  432.   sregs.ds = cs;
  433.   regs.e.edi = RM_regs;
  434.   sregs.es = ds;
  435.  
  436.   int86x (0x31, ®s, ®s, &sregs);
  437.   * cb_ip = regs.x.dx;
  438.   * cb_cs = regs.x.cx;
  439.   return (((regs.e.flags & 1) == 0) ? DOS_SUCCESS : DOS_FAILURE);
  440. }
  441.  
  442. static int
  443. DPMI_free_RM_call_back (unsigned short cb_ip, unsigned short cb_cs)
  444. {
  445.   union REGS regs;
  446.   
  447.   regs.x.ax = 0x304;
  448.   regs.x.cx = cb_cs;
  449.   regs.x.dx = cb_ip;
  450.   int86 (0x31, ®s, ®s);
  451.   return (((regs.e.flags & 1) == 0) ? DOS_SUCCESS : DOS_FAILURE);
  452. }
  453.  
  454. #endif /* DPMI_RM_HANDLER_PROTECTED */
  455.  
  456. #ifdef DPMI_RM_HANDLER_REAL
  457.  
  458. static int
  459. DPMI_allocate_DOS_block (unsigned short size,
  460.              unsigned short * rm_seg,
  461.              unsigned short * pm_sel)
  462. {
  463.   union REGS regs;
  464.   
  465.   regs.x.ax = 0x100;
  466.   regs.x.bx = ((((unsigned) size) + 15) >> 4);    /* paragraphs */
  467.   int86 (0x31, & regs, & regs);
  468.   * rm_seg = regs.x.ax;
  469.   * pm_sel = regs.x.dx;
  470.   return (((regs.e.flags & 1) == 0) ? DOS_SUCCESS : DOS_FAILURE);
  471. }
  472.  
  473. static int
  474. DPMI_free_DOS_block (unsigned short selector)
  475. {
  476.   union REGS regs;
  477.   
  478.   regs.x.ax = 0x101;
  479.   regs.x.dx = selector;
  480.   int86 (0x31, & regs, & regs);
  481.   return (((regs.e.flags & 1) == 0) ? DOS_SUCCESS : DOS_FAILURE);
  482. }
  483.  
  484. #endif /* DPMI_RM_HANDLER_REAL */
  485.  
  486. #ifdef DOSX_RM_HANDLER_REAL
  487.  
  488. static int
  489. DOSX_allocate_DOS_block (unsigned short size,
  490.              unsigned short * rm_seg)
  491. {
  492.   union REGS regs;
  493. #if 0
  494.   
  495.   regs.x.ax = 0x25c0;
  496.   regs.x.bx = ((((unsigned) size) + 15) >> 4);    /* paragraphs */
  497.   int86 (0x21, & regs, & regs);
  498.   if ((regs.e.flags & 1) == 0)
  499.   {
  500.     * rm_seg = regs.x.ax;
  501.     return (DOS_SUCCESS);
  502.   }
  503.   if (regs.x.ax == 0x8)
  504.     errno = ENOMEM;
  505.   else
  506.     errno = EFAULT;
  507.   return (DOS_FAILURE);
  508.  
  509. #else /* not 0 */
  510.  
  511.   regs.h.ah = 0x48;
  512.   regs.x.bx = ((((unsigned) size) + 15) >> 4);    /* paragraphs */
  513.   int86 (0x21, & regs, & regs);
  514.   * rm_seg = regs.x.ax;
  515.   if ((regs.e.flags & 1) != 0)
  516.   {
  517.     errno = ENOMEM;
  518.     return (DOS_FAILURE);
  519.   }
  520.   return (DOS_SUCCESS);
  521.  
  522. #endif /* 0 */
  523. }
  524.  
  525. static int
  526. DOSX_free_DOS_block (unsigned short seg)
  527. {
  528.   union REGS regs;
  529. #if 0
  530.   
  531.   regs.x.ax = 0x25c1;
  532.   regs.x.cx = seg;
  533.   int86 (0x21, & regs, & regs);
  534.  
  535. #else /* not 0 */
  536.  
  537.   struct SREGS sregs;
  538.  
  539.   regs.h.ah = 0x49;
  540.   segread (&sregs);
  541.   sregs.es = seg;
  542.   int86x (0x21, & regs, & regs, & sregs);
  543.  
  544. #endif /* 0 */
  545.   return (((regs.e.flags & 1) == 0) ? DOS_SUCCESS : DOS_FAILURE);
  546. }
  547.  
  548. #endif /* DOSX_RM_HANDLER_REAL */
  549.  
  550. #ifndef DOSX_PM_HANDLER_UNTOUCHED
  551.  
  552. static void
  553. DOSX_PM_getvector (unsigned vecnum, unsigned * eip, unsigned * cs)
  554. {
  555.   union REGS regs;
  556.   struct SREGS sregs;
  557.   
  558.   regs.x.ax = 0x2502;
  559.   regs.h.cl = (vecnum & 0xff);
  560.   segread (&sregs);
  561.   int86x (0x21, ®s, ®s, &sregs);
  562.   * eip = regs.e.ebx;
  563.   * cs = ((unsigned) sregs.es);
  564.   return;
  565. }
  566.  
  567. static void
  568. DOSX_installvector (unsigned vecnum, unsigned eip, unsigned cs)
  569. {
  570.   union REGS regs;
  571.   struct SREGS sregs;
  572.   
  573.   regs.x.ax = 0x2506;
  574.   regs.h.cl = (vecnum & 0xff);
  575.   regs.e.edx = eip;
  576.   segread (&sregs);
  577.   sregs.ds = cs;
  578.   int86x (0x21, ®s, ®s, &sregs);
  579.   return;
  580. }
  581.  
  582. static void
  583. DOSX_restore_vector (unsigned vecnum, unsigned eip,
  584.              unsigned cs, unsigned rmode)
  585. {
  586.   union REGS regs;
  587.   struct SREGS sregs;
  588.   
  589.   segread (&sregs);
  590.   sregs.ds = cs;
  591.   regs.e.edx = eip;
  592.   regs.e.ebx = rmode;
  593.   regs.x.ax = 0x2507;
  594.   regs.h.cl = (vecnum & 0xff);
  595.   int86x (0x21, ®s, ®s, &sregs);
  596.   return;
  597. }
  598.  
  599. #endif /* DOSX_PM_HANDLER_UNTOUCHED */
  600.  
  601. #if (!(defined(DOSX_RM_HANDLER_UNTOUCHED) && defined(DOSX_PM_HANDLER_UNTOUCHED)))
  602.  
  603. static void
  604. DOSX_RM_getvector (unsigned vecnum, unsigned * vector)
  605. {
  606.   union REGS regs;
  607.  
  608.   regs.x.ax = 0x2503;
  609.   regs.h.cl = (vecnum & 0xff);
  610.   int86 (0x21, ®s, ®s);
  611.   * vector = regs.e.ebx;
  612.   return;
  613. }
  614.  
  615. #endif /* !(DOSX_RM_HANDLER_UNTOUCHED && DOSX_PM_HANDLER_UNTOUCHED) */
  616.  
  617. #ifndef DOSX_RM_HANDLER_UNTOUCHED
  618.  
  619. static int
  620. DOSX_RM_setvector (unsigned vecnum, unsigned rm_address)
  621. {
  622.   union REGS regs;
  623.   
  624.   regs.x.ax = 0x2505;
  625.   regs.h.cl = (vecnum & 0xff);
  626.   regs.e.ebx = rm_address;
  627.   int86 (0x31, ®s, ®s);
  628.   return (((regs.e.flags & 1) == 0) ? DOS_SUCCESS : DOS_FAILURE);
  629. }
  630.  
  631. #if 0
  632. static int
  633. DOSX_convert_PM_to_RM_address (unsigned short sel, unsigned offset,
  634.                    unsigned length, unsigned * rm_address)
  635. {
  636.   union REGS regs;
  637.   struct SREGS sregs;
  638.  
  639.   segread (&sregs);
  640.   sregs.es = sel;
  641.   regs.e.ebx = offset;
  642.   regs.e.ecx = length;
  643.   regs.e.eax = 0x250F;
  644.   int86x (0x21, ®s, ®s, &sregs);
  645.   * rm_address = regs.e.ecx;
  646.   return (((regs.e.flags & 1) == 0) ? DOS_SUCCESS : DOS_FAILURE);
  647. }
  648. #endif /* 0 */
  649.  
  650. #endif /* DOSX_RM_HANDLER_UNTOUCHED */
  651.  
  652. static unsigned 
  653.   old_PM_vector_eip, 
  654.   old_PM_vector_cs;
  655.  
  656. static union RM_address old_RM_vector;
  657.  
  658. static void
  659.   * scheme_PM_vector = ((void *) NULL),
  660.   * scheme_RM_vector = ((void *) NULL);
  661.  
  662. #if (!defined (DOSX_PM_HANDLER_UNTOUCHED)) || (!defined (DPMI_PM_HANDLER_UNTOUCHED))
  663. static void *
  664. make_PM_trampoline (void (* hook) (void))
  665. {
  666.   void * trampoline;
  667.   INSN_DECLS ();
  668.  
  669.   trampoline = (malloc (TRAMP_SIZE (6)));
  670.   if (trampoline != ((void *) NULL))
  671.   {
  672.     INIT_INSNS (trampoline);
  673.     PUSH_INSN (old_PM_vector_cs);
  674.     PUSH_INSN (old_PM_vector_eip);
  675.     PUSH_INSN (& modifier_mask);
  676.     PUSH_INSN (unshifted_scan_code_to_ascii);
  677.     PUSH_INSN (shifted_scan_code_to_ascii);
  678.     PUSH_INSN (getDS ());
  679.     JMP_INSN (hook);
  680.     HLT_INSNS (6);
  681.   }
  682.   return (trampoline);
  683. }
  684. #endif /* !DOSX_PM_HANDLER_UNTOUCHED || !DPMI_PM_HANDLER_UNTOUCHED */
  685.  
  686. #ifdef DPMI_RM_HANDLER_PROTECTED
  687. static void *
  688. make_RM_trampoline (void (* hook) (void))
  689. {
  690.   void * trampoline;
  691.   INSN_DECLS ();
  692.  
  693.   trampoline = (malloc (TRAMP_SIZE (6)));
  694.   if (trampoline != ((void *) NULL))
  695.   {
  696.     INIT_INSNS (trampoline);
  697.     PUSH_INSN (old_RM_vector.x.seg);
  698.     PUSH_INSN (old_RM_vector.x.off);
  699.     PUSH_INSN (& modifier_mask);
  700.     PUSH_INSN (unshifted_scan_code_to_ascii);
  701.     PUSH_INSN (shifted_scan_code_to_ascii);
  702.     PUSH_INSN (getDS ());
  703.     JMP_INSN (hook);
  704.     HLT_INSNS (6);
  705.   }
  706.   return (trampoline);
  707. }
  708. #endif /* DPMI_RM_HANDLER_PROTECTED */
  709.  
  710. #ifdef DPMI_RM_HANDLER_PROTECTED
  711.   static union RM_address DPMI_RM_call_back;
  712.   static void * DPMI_RM_regs = ((void *) NULL);
  713. #endif /* DPMI_RM_HANDLER_PROTECTED */
  714.  
  715. #ifdef DPMI_RM_HANDLER_REAL
  716.   static unsigned short DPMI_RM_selector = 0;
  717. #endif /* DPMI_RM_HANDLER_REAL */
  718.  
  719. static char * DPMI_env_var = "MITSCHEME_DPMI_EXT_KBD";
  720.  
  721. static int
  722. DPMI_restore_kbd_hook (void)
  723. {
  724.   if (!(install_kbd_hook_p (DPMI_env_var)))
  725.     return (DOS_FAILURE);
  726.  
  727. #ifdef DPMI_RM_HANDLER_REAL
  728.   if (DPMI_RM_selector != 0)
  729.   {
  730.     if (((DPMI_RM_setvector (DOS_INTVECT_SYSTEM_SERVICES,
  731.                  old_RM_vector.x.off,
  732.                  old_RM_vector.x.seg))
  733.      != DOS_SUCCESS)
  734.     || ((DPMI_free_DOS_block (DPMI_RM_selector)) != DOS_SUCCESS))
  735.     {
  736.       errno = EACCES;
  737.       return (DOS_FAILURE);
  738.     }
  739.     DPMI_RM_selector = 0;
  740.     free (scheme_RM_vector);
  741.     scheme_RM_vector = ((void *) NULL);
  742.   }
  743. #endif /* #ifdef DPMI_RM_HANDLER_REAL */
  744.  
  745. #ifdef DPMI_RM_HANDLER_PROTECTED
  746.   if (scheme_RM_vector != ((void *) NULL))
  747.   {
  748.     if (((DPMI_RM_setvector (DOS_INTVECT_SYSTEM_SERVICES,
  749.                  old_RM_vector.x.off,
  750.                  old_RM_vector.x.seg))
  751.      != DOS_SUCCESS)
  752.     || ((DPMI_free_RM_call_back (DPMI_RM_call_back.x.off,
  753.                      DPMI_RM_call_back.x.seg))
  754.         != DOS_SUCCESS))
  755.     {
  756.       errno = EACCES;
  757.       return (DOS_FAILURE);
  758.     }
  759.     free (DPMI_RM_regs);
  760.     free (scheme_RM_vector);
  761.     scheme_RM_vector = ((void *) NULL);
  762.   }
  763. #endif /* DPMI_RM_HANDLER_PROTECTED */
  764.  
  765. #ifndef DPMI_PM_HANDLER_UNTOUCHED
  766.   if (scheme_PM_vector != ((void *) NULL))
  767.   {
  768.     if ((DPMI_PM_setvector (DOS_INTVECT_SYSTEM_SERVICES,
  769.                 old_PM_vector_eip,
  770.                 old_PM_vector_cs))
  771.     != DOS_SUCCESS)
  772.     {
  773.       errno = EACCES;
  774.       return (DOS_FAILURE);
  775.     }
  776.     free (scheme_PM_vector);
  777.     scheme_PM_vector = ((void *) NULL);
  778.   }
  779. #endif /* DPMI_PM_HANDLER_UNTOUCHED */
  780.  
  781.   return (DOS_SUCCESS);
  782. }
  783.  
  784. #if defined(DPMI_RM_HANDLER_REAL) || defined(DOSX_RM_HANDLER_REAL)
  785.  
  786. unsigned char RM_handler_pattern[] =
  787. {
  788.             /*  chain:                    */
  789. 0x9d,            /* 0    popf                    */
  790. 0xea,0,0,0,0,        /* 1    jmpf    next_in_chain            */
  791.             /*  kbd_isr:                    */
  792. 0x9c,            /* 6    pushf                    */
  793. 0x80,0xfc,0x4f,        /* 7    cmp    ah,4fh                */
  794. 0x75,0xf4,        /* a    jne    chain                */
  795. 0x3c,0x39,        /* c    cmp    al,39h                */
  796. 0x77,0xf0,        /* e    ja    chain                */
  797. 0x53,            /* 10    push    bx    ; Preserve bx        */
  798. 0x50,            /* 11    push    ax    ; Preserve scan code    */
  799. 0xb4,2,            /* 12    mov    ah,2h                */
  800. 0xcd,0x16,        /* 14    int    16h    ; Get modifier bits    */
  801. 0x2e,0x22,6,0xf4,0,    /* 16    and    al,cs:modifier mask        */
  802. 0x5b,            /* 1b    pop    bx    ; Get scan code        */
  803. 0x53,            /* 1c    push    bx                */
  804. 0x81,0xe3,0x3f,0,    /* 1d    and    bx,3fh    ; Drop fncn        */
  805. 0x3c,8,            /* 21    cmp    al,8h    ; Only meta bit set?    */
  806. 0x74,0xb,        /* 23    je    do_unshifted            */
  807. 0x3c,0,            /* 25    cmp    al,0    ; No modifier bits set? */
  808. 0x74,7,            /* 27    je    do_unshifted            */
  809.             /*  do_shifted:                    */
  810. 0x2e,0x8a,0x9f,0x80,0,    /* 29    mov    bl,cs:shifted_table[bx]        */
  811. 0xeb,5,            /* 2e    jmp    merge                */
  812.             /*  do_unshifted:                */
  813. 0x2e,0x8a,0x9f,0xba,0,    /* 30    mov    bl,cs:unshifted_table[bx]    */
  814.             /*  merge:                    */
  815. 0x80,0xfb,0,        /* 35    cmp    bl,0    ; No translation?    */
  816. 0x74,0x37,        /* 38    je    abort_translation        */
  817. 0x0f,0xba,0xe0,2,    /* 3a    bt    al,2h    ; Control set?        */
  818. 0x73,3,            /* 3e    jnc    after_ctrl            */
  819. 0x80,0xe3,0x9f,        /* 40    and    bl,09fh ; controlify        */
  820.             /*  after_ctrl:                    */
  821. 0x0f,0xba,0xe0,3,    /* 43    bt    al,3h    ; Alt set?        */
  822. 0x73,3,            /* 47    jnc    after_meta            */
  823. 0x80,0xcb,0x80,        /* 49    or    bl,080h ; metify        */
  824.             /*  after_meta:                    */
  825. 0x80,0xfb,0xf0,        /* 4c   cmp    bl,0f0h ; M-p ?            */
  826. 0x74,0x20,        /* 4f    je    abort_translation        */
  827. 0x58,            /* 51    pop    ax                */
  828. 0x51,            /* 52    push    cx    ; Preserve cx        */
  829. 0x50,            /* 53    push    ax                */
  830. 0x8a,0xe8,        /* 54    mov    ch,al    ; Scan code        */
  831. 0x80,0xfb,0,        /* 56    cmp    bl,0    ; C-Space?        */
  832. 0x75,2,            /* 59   jne    after_ctrl_space        */
  833. 0xb5,3,            /* 5b    mov    ch,3    ; Fudge scan code    */
  834.             /*  after_ctrl_space:                */
  835. 0x8a,0xcb,        /* 5d    mov    cl,bl    ; ASCII value        */
  836. 0xb4,5,            /* 5f    mov    ah,05h    ; fcn. number        */
  837. 0xcd,0x16,        /* 61    int    16h    ; Record keystroke    */
  838. 0x58,            /* 63    pop    ax    ; Restore registers    */
  839. 0x59,            /* 64    pop    cx                */
  840. 0x5b,            /* 65    pop    bx                */
  841. 0x55,            /* 66    push    bp                */
  842. 0x8b,0xec,        /* 67    mov    bp,sp                */
  843. 0x80,0x66,8,0xfe,    /* 69    and    8[bp],0feh  ; clc iret's flags    */
  844. 0x5d,            /* 6d    pop    bp                */
  845. 0x9d,            /* 6e    popf                    */
  846. 0xf8,            /* 6f    clc                    */
  847. 0xcf,            /* 70    iret                    */
  848.             /*  abort_translation:                */
  849. 0x58,            /* 71    pop    ax                */
  850. 0x5b,            /* 72    pop    bx                */
  851. 0xeb,0x8b        /* 73    jmp    chain                */
  852.             /* 75    PAD                    */
  853. };
  854.  
  855. #define PATTERN_SIZE        0x75
  856. #define PADDED_PATTERN_SIZE    0x80
  857. #define PATTERN_CHAIN_OFFSET    2
  858. #define PATTERN_START_OFFSET    6
  859. #define RM_ISR_TABLE_SIZE    0x3a
  860. #define RM_ISR_TOTAL_SIZE                    \
  861.   (PADDED_PATTERN_SIZE + (2 * RM_ISR_TABLE_SIZE) + 1)
  862. #define RM_ISR_MASK_OFFSET    (RM_ISR_TOTAL_SIZE - 1)
  863.  
  864. static void *
  865. make_RM_handler (void)
  866. {
  867.   unsigned char * copy;
  868.   unsigned short * wordptr;
  869.  
  870.   if (((sizeof (RM_handler_pattern)) != PATTERN_SIZE)
  871.       || ((sizeof (shifted_scan_code_to_ascii)) != RM_ISR_TABLE_SIZE)
  872.       || ((sizeof (unshifted_scan_code_to_ascii)) != RM_ISR_TABLE_SIZE)
  873.       || (RM_ISR_MASK_OFFSET != 0xf4))
  874.   {
  875.     fprintf (stderr, "make_RM_handler: Inconsistent sizes!\n");
  876.     fprintf (stderr, "       PATTERN_SIZE = %d\n", PATTERN_SIZE);
  877.     fprintf (stderr, "and (sizeof (RM_handler_pattern)) = %d\n",
  878.          (sizeof (RM_handler_pattern)));
  879.     fprintf (stderr, "       RM_ISR_TABLE_SIZE = %d\n",
  880.          RM_ISR_TABLE_SIZE);
  881.  
  882.     fprintf (stderr, "and (sizeof (shifted_scan_code_to_ascii)) = %d\n",
  883.          (sizeof (shifted_scan_code_to_ascii)));
  884.     fprintf (stderr, "and (sizeof (unshifted_scan_code_to_ascii)) = %d\n",
  885.          (sizeof (unshifted_scan_code_to_ascii)));
  886.     fprintf (stderr, "       RM_ISR_MASK_OFFSET  = 0x%x <> 0xf4",
  887.          RM_ISR_MASK_OFFSET);
  888.     errno = EFAULT;
  889.     return ((void *) NULL);
  890.   }
  891.  
  892.   copy = ((unsigned char *) (malloc (RM_ISR_TOTAL_SIZE)));
  893.   if (copy == ((unsigned char *) NULL))
  894.     return ((void *) NULL);
  895.  
  896.   memcpy (copy, RM_handler_pattern, (sizeof (RM_handler_pattern)));
  897.   memcpy ((copy + PADDED_PATTERN_SIZE),
  898.       shifted_scan_code_to_ascii,
  899.       RM_ISR_TABLE_SIZE);
  900.   memcpy ((copy + PADDED_PATTERN_SIZE + RM_ISR_TABLE_SIZE),
  901.       unshifted_scan_code_to_ascii,
  902.       RM_ISR_TABLE_SIZE);
  903.  
  904.   wordptr = ((unsigned short *) (copy + PATTERN_CHAIN_OFFSET));
  905.   * wordptr++ = old_RM_vector.x.off;
  906.   * wordptr = old_RM_vector.x.seg;
  907.   * (copy + RM_ISR_MASK_OFFSET) = modifier_mask;
  908.  
  909.   return ((void *) copy);
  910. }
  911.  
  912. #endif /* DPMI_RM_HANDLER_REAL || DOSX_RM_HANDLER_REAL */
  913.  
  914. static int
  915. DPMI_install_kbd_hook (void)
  916. {
  917.   if (!(install_kbd_hook_p (DPMI_env_var)))
  918.     return (DOS_FAILURE);
  919.  
  920. #ifndef DPMI_PM_HANDLER_UNTOUCHED
  921.  
  922.   DPMI_PM_getvector (DOS_INTVECT_SYSTEM_SERVICES,
  923.              & old_PM_vector_eip,
  924.              & old_PM_vector_cs);
  925.  
  926.   {
  927.     extern void DPMI_PM_scheme_system_isr (void);
  928.     void * PM_trampoline;
  929.  
  930.     PM_trampoline = (make_PM_trampoline (DPMI_PM_scheme_system_isr));
  931.     if (PM_trampoline == ((void *) NULL))
  932.     {
  933.       errno = ENOMEM;
  934.       return (DOS_FAILURE);
  935.     }
  936.     if ((DPMI_PM_setvector (DOS_INTVECT_SYSTEM_SERVICES,
  937.                 ((unsigned) PM_trampoline),
  938.                 (getCS ())))
  939.     != DOS_SUCCESS)
  940.     {
  941.       errno = EACCES;
  942.       free (PM_trampoline);
  943.       return (DOS_FAILURE);
  944.     }
  945.     scheme_PM_vector = PM_trampoline;
  946.   }
  947.  
  948. #endif /* DPMI_PM_HANDLER_UNTOUCHED */
  949.  
  950. #ifndef DPMI_RM_HANDLER_UNTOUCHED
  951.  
  952.   DPMI_RM_getvector (DOS_INTVECT_SYSTEM_SERVICES,
  953.              & old_RM_vector.x.off,
  954.              & old_RM_vector.x.seg);
  955.  
  956. #  ifdef DPMI_RM_HANDLER_PROTECTED
  957.  
  958.   {
  959.     extern void DPMI_RM_scheme_system_isr (void);
  960.     struct DPMI_RM_REGS * RM_regs;
  961.     union RM_address RM_call_back;
  962.     void * RM_trampoline;
  963.  
  964.     RM_regs = ((struct DPMI_RM_REGS *)
  965.            (malloc (sizeof (struct DPMI_RM_REGS))));
  966.     if (RM_regs == ((struct DPMI_RM_REGS *) NULL))
  967.     {
  968.       DPMI_restore_kbd_hook ();
  969.       errno = ENOMEM;
  970.       return (DOS_FAILURE);
  971.     }
  972.  
  973.     RM_regs->ss = 0;
  974.     RM_regs->sp = 0;
  975.     RM_regs->old_vector_ip = (old_RM_vector.x.off);
  976.     RM_regs->old_vector_cs = (old_RM_vector.x.seg);
  977.  
  978.     RM_trampoline = (make_RM_trampoline (DPMI_RM_scheme_system_isr));
  979.     if (RM_trampoline == ((void *) NULL))
  980.     {
  981.       free (RM_regs);
  982.       DPMI_restore_kbd_hook ();
  983.       errno = ENOMEM;
  984.       return (DOS_FAILURE);
  985.     }
  986.  
  987.     if (((DPMI_allocate_RM_call_back (& RM_call_back.x.off,
  988.                       & RM_call_back.x.seg,
  989.                       ((unsigned) RM_trampoline),
  990.                       ((unsigned) (getCS ())),
  991.                       ((unsigned) RM_regs),
  992.                       ((unsigned) (getDS ()))))
  993.      != DOS_SUCCESS)
  994.     || ((DPMI_RM_setvector (DOS_INTVECT_SYSTEM_SERVICES,
  995.                 RM_call_back.x.off,
  996.                 RM_call_back.x.seg))
  997.         != DOS_SUCCESS))
  998.     {
  999.       free (RM_trampoline);
  1000.       free (RM_regs);
  1001.       DPMI_restore_kbd_hook ();
  1002.       errno = EACCES;
  1003.       return (DOS_FAILURE);
  1004.     }
  1005.     scheme_RM_vector = RM_trampoline;
  1006.     DPMI_RM_regs = ((void *) RM_regs);
  1007.     DPMI_RM_call_back = RM_call_back;
  1008.   }
  1009.  
  1010. #  else  /* not DPMI_RM_HANDLER_PROTECTED = DPMI_RM_HANDLER_REAL */
  1011.  
  1012.   {
  1013.     void * RM_handler;
  1014.     unsigned short real_mode_segment;
  1015.     unsigned short prot_mode_selector;
  1016.  
  1017.     RM_handler = (make_RM_handler ());
  1018.     if (RM_handler == ((void *) NULL))
  1019.     {
  1020.       int saved_errno = errno;
  1021.  
  1022.       DPMI_restore_kbd_hook ();
  1023.       errno = saved_errno;
  1024.       return (DOS_FAILURE);
  1025.     }
  1026.  
  1027.     if ((DPMI_allocate_DOS_block (RM_ISR_TOTAL_SIZE,
  1028.                   & real_mode_segment,
  1029.                   & prot_mode_selector))
  1030.     != DOS_SUCCESS)
  1031.     {
  1032.       free (RM_handler);
  1033.       DPMI_restore_kbd_hook ();
  1034.       errno = ENOMEM;
  1035.       return (DOS_FAILURE);
  1036.     }
  1037.  
  1038.     farcpy (0, prot_mode_selector,
  1039.         ((unsigned) RM_handler), (getDS ()),
  1040.         RM_ISR_TOTAL_SIZE);
  1041.  
  1042.     if ((DPMI_RM_setvector (DOS_INTVECT_SYSTEM_SERVICES,
  1043.                 PATTERN_START_OFFSET,
  1044.                 real_mode_segment))
  1045.     != DOS_SUCCESS)
  1046.     {
  1047.       DPMI_free_DOS_block (prot_mode_selector);
  1048.       free (RM_handler);
  1049.       DPMI_restore_kbd_hook ();
  1050.       errno = EACCES;
  1051.       return (DOS_FAILURE);
  1052.     }
  1053.  
  1054.     DPMI_RM_selector = prot_mode_selector;
  1055.     scheme_RM_vector = RM_handler;        /* Kludge! */
  1056.   }
  1057.  
  1058. #  endif /* not DPMI_RM_HANDLER_PROTECTED */
  1059. #endif /* DPMI_RM_HANDLER_UNTOUCHED */
  1060.   return (DOS_SUCCESS);
  1061. }
  1062.  
  1063. #ifdef DOSX_RM_HANDLER_REAL
  1064.   static unsigned short DOSX_RM_segment = 0;
  1065. #endif /* DOSX_RM_HANDLER_REAL */
  1066. #ifdef DOSX_USE_INT_INTERCEPT
  1067.   static unsigned char kludge;
  1068. #endif /* DOSX_USE_INT_INTERCEPT */
  1069.  
  1070. static char * DOSX_env_var = "MITSCHEME_DOSX_EXT_KBD";
  1071.  
  1072. static int
  1073. DOSX_install_kbd_hook (void)
  1074. {
  1075.   if (!(install_kbd_hook_p (DOSX_env_var)))
  1076.     return (DOS_FAILURE);
  1077.   
  1078. #ifdef DOSX_USE_INT_INTERCEPT
  1079.   {
  1080.     int_intercept (DOS_INTVECT_SYSTEM_SERVICES, 
  1081.            bios_keyboard_handler, 
  1082.            256);
  1083.  
  1084.     scheme_PM_vector = ((void *) & kludge);
  1085.   }
  1086. #else /* not DOSX_USE_INT_INTERCEPT */
  1087. #ifndef DOSX_PM_HANDLER_UNTOUCHED
  1088.   {
  1089.     extern void DOSX_scheme_system_isr (void);
  1090.     void * trampoline;
  1091.  
  1092.     DOSX_PM_getvector (DOS_INTVECT_SYSTEM_SERVICES,
  1093.                & old_PM_vector_eip,
  1094.                & old_PM_vector_cs);
  1095.     DOSX_RM_getvector (DOS_INTVECT_SYSTEM_SERVICES,
  1096.                & old_RM_vector.fp);
  1097.  
  1098.     trampoline = (make_PM_trampoline (DOSX_scheme_system_isr));
  1099.     if (trampoline == ((void *) NULL))
  1100.       return (DOS_FAILURE);
  1101.  
  1102.     DOSX_installvector (DOS_INTVECT_SYSTEM_SERVICES,
  1103.             ((unsigned) trampoline),
  1104.             ((unsigned) (getCS ())));
  1105.  
  1106.     scheme_PM_vector = trampoline;
  1107.   }
  1108. #endif /* DOSX_PM_HANDLER_UNTOUCHED */
  1109.  
  1110. #ifdef DOSX_RM_HANDLER_REAL
  1111.   {
  1112.     void * RM_handler;
  1113.     union RM_address new_handler;
  1114.  
  1115.     DOSX_RM_getvector (DOS_INTVECT_SYSTEM_SERVICES,
  1116.                ((unsigned *) & old_RM_vector));
  1117.  
  1118.     RM_handler = (make_RM_handler ());
  1119.     if (RM_handler == ((void *) NULL))
  1120.       return (DOS_FAILURE);
  1121.  
  1122. #if 0
  1123.  
  1124.     if ((DOSX_convert_PM_to_RM_address ((getDS ()), ((unsigned) RM_handler),
  1125.                     RM_ISR_TOTAL_SIZE,
  1126.                     ((unsigned *) & new_handler)))
  1127.     != DOS_SUCCESS)
  1128.     {
  1129.       int saved_errno = errno;
  1130.  
  1131.       fflush (stdout);
  1132.       free (RM_handler);
  1133.       errno = saved_errno;
  1134.       return (DOS_FAILURE);
  1135.     }
  1136.     
  1137.     if ((new_handler.x.off & 0xf) != 0)
  1138.     {
  1139.       fflush (stdout);
  1140.       free (RM_handler);
  1141.       errno = EFAULT;
  1142.       return (DOS_FAILURE);
  1143.     }
  1144.  
  1145.     normalize_RM_address (& new_handler);
  1146.  
  1147.     if ((DOSX_RM_setvector (DOS_INTVECT_SYSTEM_SERVICES,
  1148.                 ((unsigned) new_handler)))
  1149.     != DOS_SUCCESS)
  1150.     {
  1151.       fflush (stdout);
  1152.       free (RM_handler);
  1153.       errno = EFAULT;
  1154.       return (DOS_FAILURE);
  1155.     }
  1156.  
  1157. #else /* not 0 */
  1158.     
  1159.     if ((DOSX_allocate_DOS_block (RM_ISR_TOTAL_SIZE, &new_handler.x.seg))
  1160.     != DOS_SUCCESS)
  1161.     {
  1162.       int saved_errno = errno;
  1163.  
  1164.       free (RM_handler);
  1165.       errno = saved_errno;
  1166.       return (DOS_FAILURE);
  1167.     }
  1168.     new_handler.x.off = 0;
  1169.  
  1170.     /* This assumes that the bottom 1 Mb of memory is mapped to the DOS
  1171.        memory, so it can be accessed directly.
  1172.      */
  1173.  
  1174.     memcpy (((void *) ((unsigned long) new_handler.x.seg << 4)),
  1175.         RM_handler,
  1176.         RM_ISR_TOTAL_SIZE);
  1177.  
  1178.     if ((DOSX_RM_setvector (DOS_INTVECT_SYSTEM_SERVICES, new_handler.fp))
  1179.     != DOS_SUCCESS)
  1180.     {
  1181.       DOSX_free_DOS_block (new_handler.x.seg);
  1182.       fflush (stdout);
  1183.       free (RM_handler);
  1184.       errno = EFAULT;
  1185.       return (DOS_FAILURE);
  1186.     }
  1187.     DOSX_RM_segment = new_handler.x.seg;
  1188.  
  1189. #endif /* 0 */
  1190.  
  1191.     scheme_RM_vector = RM_handler;
  1192.   }
  1193.  
  1194. #endif /* DOSX_PM_HANDLER_UNTOUCHED */
  1195. #endif /* DOSX_USE_INT_INTERCEPT */
  1196.   return (DOS_SUCCESS);
  1197. }
  1198.  
  1199. static int
  1200. DOSX_restore_kbd_hook (void)
  1201. {
  1202.   if (!(install_kbd_hook_p (DOSX_env_var)))
  1203.     return (DOS_FAILURE);
  1204.  
  1205. #ifdef DOSX_USE_INT_INTERCEPT
  1206.  
  1207.   (void) int_restore (DOS_INTVECT_SYSTEM_SERVICES);
  1208.   scheme_PM_vector = ((void *) NULL);
  1209.   
  1210. #else /* not DOSX_USE_INT_INTERCEPT */
  1211. #ifndef DOSX_PM_HANDLER_UNTOUCHED
  1212.  
  1213.   DOSX_restore_vector (DOS_INTVECT_SYSTEM_SERVICES,
  1214.                old_PM_vector_eip, 
  1215.                old_PM_vector_cs,
  1216.                old_RM_vector.fp);
  1217.  
  1218.   free (scheme_PM_vector);
  1219.   scheme_PM_vector = ((void *) NULL);
  1220.  
  1221. #endif /* DOSX_PM_HANDLER_UNTOUCHED */
  1222.  
  1223. #ifdef DOSX_RM_HANDLER_REAL
  1224.  
  1225.   if ((DOSX_RM_setvector (DOS_INTVECT_SYSTEM_SERVICES,
  1226.               ((unsigned) old_RM_vector)))
  1227.       != DOS_SUCCESS)
  1228.     return (DOS_FAILURE);
  1229.  
  1230. #if 1
  1231.  
  1232.   if ((DOSX_free_DOS_block (DOSX_RM_segment)) != DOS_SUCCESS)
  1233.     return (DOS_FAILURE);
  1234.   DOSX_RM_segment = 0;
  1235.  
  1236. #endif /* 1 */
  1237.  
  1238.   free (scheme_RM_vector);
  1239.   scheme_RM_vector = ((void *) NULL);
  1240.  
  1241. #endif /* DOSX_RM_HANDLER_REAL */
  1242. #endif /* DOSX_USE_INT_INTERCEPT */
  1243.   return (DOS_SUCCESS);
  1244. }
  1245.  
  1246. int
  1247. dos_install_kbd_hook (void)
  1248. {
  1249.   if (scheme_PM_vector != ((void *) NULL))
  1250.   {
  1251.     errno = ELOOP;
  1252.     return (DOS_FAILURE);
  1253.   }
  1254.   if (under_DPMI_p ())
  1255.     return (DPMI_install_kbd_hook ());
  1256.   else
  1257.     return (DOSX_install_kbd_hook ());
  1258. }
  1259.  
  1260. int
  1261. dos_restore_kbd_hook (void)
  1262. {
  1263.   if ((scheme_PM_vector == ((void *) NULL))
  1264.       && (scheme_RM_vector == ((void *) NULL)))
  1265.     return (DOS_SUCCESS);
  1266.   else if (!under_DPMI_p ())
  1267.   {
  1268.     if ((DOSX_restore_kbd_hook ()) != DOS_SUCCESS)
  1269.       return (DOS_FAILURE);
  1270.   }
  1271.   else if ((DPMI_restore_kbd_hook ()) != DOS_SUCCESS)
  1272.     return (DOS_FAILURE);
  1273.  
  1274.   if (scheme_PM_vector != ((void *) NULL))
  1275.   {
  1276.     free (scheme_PM_vector);
  1277.     scheme_PM_vector = ((void *) NULL);
  1278.   }
  1279.   if (scheme_RM_vector != ((void *) NULL))
  1280.   {
  1281.     free (scheme_RM_vector);
  1282.     scheme_RM_vector = ((void *) NULL);
  1283.   }
  1284.   return (DOS_SUCCESS);
  1285. }
  1286.  
  1287. unsigned char
  1288. dos_set_kbd_modifier_mask (unsigned char new_mask)
  1289. {
  1290.   unsigned char old_mask = modifier_mask;
  1291.  
  1292.   modifier_mask = new_mask;
  1293.  
  1294. #ifdef DPMI_RM_HANDLER_REAL
  1295.  
  1296.   if (DPMI_RM_selector != 0)
  1297.     farcpy (RM_ISR_MASK_OFFSET, DPMI_RM_selector, 
  1298.         ((unsigned) (& modifier_mask)), (getDS ()),
  1299.         1);
  1300.  
  1301. #endif /* DPMI_RM_HANDLER_REAL */
  1302.  
  1303. #ifdef DOSX_RM_HANDLER_REAL
  1304.  
  1305.   if (DOSX_RM_segment != 0)
  1306.     (* ((unsigned char *)
  1307.     ((((unsigned long) DOSX_RM_segment) << 4) + RM_ISR_MASK_OFFSET)))
  1308.       = modifier_mask;
  1309.  
  1310. #endif /* DOSX_RM_HANDLER_REAL */
  1311.  
  1312.   return (old_mask);
  1313. }
  1314.  
  1315. extern int EXFUN (dos_set_kbd_translation,
  1316.           (unsigned, unsigned, unsigned char));
  1317.  
  1318. #ifndef PADDED_PATTERN_SIZE
  1319. #  define PADDED_PATTERN_SIZE 0
  1320. #endif
  1321.  
  1322. #ifndef RM_ISR_TABLE_SIZE
  1323. #  define RM_ISR_TABLE_SIZE 0
  1324. #endif
  1325.  
  1326. int
  1327. dos_set_kbd_translation (unsigned shift_p,
  1328.              unsigned scan_code,
  1329.              unsigned char new)
  1330. {
  1331.   unsigned char old;
  1332.   unsigned char * table;
  1333.   unsigned offset;
  1334.  
  1335.   if (scan_code >= (sizeof (shifted_scan_code_to_ascii)))
  1336.     return (-1);
  1337.  
  1338.   if (shift_p != 0)
  1339.   {
  1340.     table = &shifted_scan_code_to_ascii[0];
  1341.     offset = PADDED_PATTERN_SIZE;
  1342.   }
  1343.   else
  1344.   {
  1345.     table = &unshifted_scan_code_to_ascii[0];
  1346.     offset = (PADDED_PATTERN_SIZE + RM_ISR_TABLE_SIZE);
  1347.   }
  1348.   old = table[scan_code];
  1349.   table[scan_code] = new;
  1350.                    
  1351.  
  1352. #ifdef DPMI_RM_HANDLER_REAL
  1353.  
  1354.   if (DPMI_RM_selector != 0)
  1355.     farcpy ((offset + scan_code),
  1356.         DPMI_RM_selector,
  1357.         ((unsigned) (& table[scan_code])),
  1358.         (getDS ()),
  1359.         1);
  1360.  
  1361. #endif /* DPMI_RM_HANDLER_REAL */
  1362.  
  1363. #ifdef DOSX_RM_HANDLER_REAL
  1364.  
  1365.   if (DOSX_RM_segment != 0)
  1366.     (* ((unsigned char *)
  1367.     ((((unsigned long) DOSX_RM_segment) << 4) + offset)))
  1368.       = new;
  1369.  
  1370. #endif /* DOSX_RM_HANDLER_REAL */
  1371.  
  1372.   return (old);
  1373. }
  1374.